#ifndef ___fuse_unlink
#define ___fuse_unlink 1

#ifndef FUSE_USE_VERSION
#define FUSE_USE_VERSION 28
#endif

#include <stdio.h>
#include <stdlib.h>
#include "mtlib.c"
#include <fuse.h>
#include <fcntl.h>
#include <errno.h>
#include "logging.c"

struct datosBorrarArch {
    char * path;
    char estado;
};

//Prototipos
int fuse_unlink(const char *);
void ___fuse_procesar_mensaje_unlink(unsigned char, mti_mensaje, struct datosBorrarArch *);

//BORRAR ARCHIVO
int fuse_unlink(const char * path) {

    mti_mensaje datosMensaje;
    int resultado;
    unsigned char centro_unlink = 0;
    unsigned int descriptorConexion;
    struct datosBorrarArch datos;

        datos.estado = 0;
        datos.path = path;

        while (centro_unlink == 0)
            centro_unlink = mtf_obtener_descriptor(1024);

        descriptorConexion = mtf_conectar(centro_unlink, MTP_INTERNO, centro_fat);

        if (descriptorConexion == 0) {
            mtf_liberar_descriptor(centro_unlink);
            return -EAGAIN;
        }

        resultado = mtf_enviar_mensaje(centro_unlink, descriptorConexion, MTE_BORRAR_ARCHIVO, (char *) datos.path);

        if (resultado == 0) {
            mtf_desconectar(centro_unlink, descriptorConexion);
            mtf_liberar_descriptor(centro_unlink);
            return -EAGAIN;
        }

        while (!datos.estado) {

            if (!mtf_recibir_mensajes(centro_unlink)) continue;

         datosMensaje = mtf_siguiente_mensaje(centro_unlink);
         ___fuse_procesar_mensaje_unlink(centro_unlink, datosMensaje, &datos);
         mtf_descartar_mensaje(centro_unlink, datosMensaje.codigo);

        }

        mtf_desconectar(centro_unlink, descriptorConexion); //desconecto la conexion del centro de mensajes
        mtf_liberar_descriptor(centro_unlink); //libero centro de mensajes con sus datos y conexiones

        switch (datos.estado) {

             case 1:
                 return -EISDIR; //es un directorio
             case 2:
                 return -ENOENT; //path no existe
             default:
                 return EXIT_SUCCESS;
       }
}

void ___fuse_procesar_mensaje_unlink(unsigned char centro_unlink, mti_mensaje datosMensaje, struct datosBorrarArch * datosBorrar) {

    if (datosMensaje.categoria != MTA_MENSAJE) return;

      switch (datosMensaje.tipo) {

        case MTE_NULL:

          mtf_enviar_mensaje(centro_unlink, datosMensaje.remitente, MTR_NULL);

        break;

        case MTR_NULL: case MTQ_MENSAJE_NO_VALIDO:

        break;

        //MENSAJES PARA BORRAR ARCHIVO
        case MTR_ARCHIVO_BORRADO:
        {
            char * nombreArchivo = NULL;

                mtf_obtener_datos(centro_unlink, datosMensaje.codigo, (char **) &nombreArchivo);

                log_registrar(descArch, "FUSE", LOG_INFO, "El archivo se borro con exito %s \n", nombreArchivo);
                free(nombreArchivo);
                }
        break;

        case MTR_ARCHIVO_NO_BORRO:
        {
            char * nombreArchivo = NULL;
            char motivo;

                mtf_obtener_datos(centro_unlink, datosMensaje.codigo, (char **) &nombreArchivo,(char *) &motivo);

                datosBorrar -> estado = motivo;
                log_registrar(descArch, "FUSE", LOG_WARN, "Archivo no se borro %s \n", nombreArchivo);
                free(nombreArchivo);
        }
        break;

        default:

              mtf_enviar_mensaje(centro_unlink, datosMensaje.remitente, MTQ_MENSAJE_NO_VALIDO);

        break;
      }
}

#endif

